1loc JS to nloc PHP

Il existe un site nommé 1loc.dev qui référence actuellement 275 snippets JS dont la spécificité est de tenir en une seule ligne.

Même si l'intéret est parfois assez limité, voici quelques-uns de ces snippets en PHP ; les différentes fonctions sont écrites sur plusieurs lignes pour rendre le code plus lisible.

1. Array

1.1 Cast a value as an array

function castArray($value) 
{
    return is_array($value) ? $value : [$value];
}
// Examples
castArray(1);
castArray([1, 2, 3]);

Notes : avec le typage fort, l'utilisation de ce genre de fonction ne devrait jamais avoir lieu.

1.2 Check if an array is empty

function isEmpty($arr)
{
    return empty($arr);
}
// Examples
isEmpty([]);            // true
isEmpty([1, 2, 3]);     // false

NB : bien que je suis pour le fait d'encapsuler certaines fonctions natives comme json_encode, htmlentities, locale etc... Ici, la question de la pertinence de le faire se pose un peu.
Lorsque l'on fait du typage fort, le count() suffit à tester si le nombre d'éléments du tableau est égal à 0. L'utilisation du empty est la source de beaucoup de bugs car empty('') fonctionne, empty([]) aussi, empty(0) aussi... et cela n'a pas vraiment de sens.

Je ne suis pas non plus d'accord avec la version JS qui ressemblerait à ceci en PHP :

function isEmpty($arr)
{
    return !is_array($arr) || count($arr) === 0;
}

Ici, la chaine "" n'est pas un tableau, et pourtant la méthode retourne true, alors que l'on souhaite savoir si le tableau est vide donc que la variable est à la fois un tableau et aussi que le nombre de ses élèments est supérieur à 0.
Donc la version que je préconise serait plutôt celle-ci :

function isEmpty($arr)
{
    return is_array($arr) && count($arr) === 0;
}

Ici, cette fonction vérifie à la fois le type de la variable et le fait que le tableau soit vide, c'est une version assez stricte et juste.

A noter que dans une version de PHP qui permet le typage fort, on écrirait directement ceci :

function isEmpty(array $arr)
{
     return count($arr) === 0;
}

Ce qui peut par contre potentiellement être un problème si le type de la variable n'est pas vérifié en amont (par exemple, c'est un enfant d'enfant d'un contenu json non maitrisé par un fournisseur).

1.3 Clone an array

Le terme 'clone' étant déjà un mot clef du langage PHP, je le renomme cloneArray pour cette proposition.

function cloneArray($array)
{
    return $array;
}
// Usage (lol)
$clonedArray = cloneArray([231]); // [231]

Alors oui, c'est assez inutile car par défaut on manipule des valeurs et non des références donc il suffit de copier la variable de façon classique $b = $a.

1.4 Compare two arrays

Cela sous entend la règle suivante : si tous les élements de deux tableaux sont identiques, alors les deux tableaux le sont.
Le code JS du site 1loc.dev propose deux solutions :
* la première est de convertir les deux tableaux en json et de comparer les chaines de caractères.
* la seconde est de vérifier d'une part si la taille des deux tableaux est la même puis de vérifier chaque élement.

En PHP, on peut directement utiliser le triple égal qui vérifie que l'ordre et le type de chaque élement du premier tableau correspond au second.

function isEqual($arrayA, $arrayB)
{
     return $arrayA === $arrayB;
}
// Examples
isEqual([1, 2, 3], [1, 2, 3]);      // true
isEqual([1, 2, 3], [1, '2', 3]);    // false

1.5 Compare two arrays regardless of order

Ici, il suffit dans un premier temps de trier les deux tableaux puis ensuite de les comparer.

function isEqual($arrayA, $arrayB)
{
    sort($arrayA);
    sort($arrayB);

    return $arrayA === $arrayB;
}
// Examples
isEqual([1, 2, 3], [1, 2, 3]);      // true
isEqual([1, 2, 3], [1, 3, 2]);      // true
isEqual([1, 2, 3], [1, '2', 3]);    // false

1.6 Convert an array of objects to a single object

Ici, c'est un peu particulier car la structure Object du JS est différente de celle du PHP ; en PHP, on continuerait de manipuler un tableau.
La fonction suivante ne gère pas les cas d'erreurs (notamment si la clef $key n'existe pas).

function toObject($arrayOfObjects, $key)
{
    $object = [];
    foreach ($arrayOfObjects as $subObject) {
        $object[$subObject[$key]] = $subObject;
    }

    return $object;
}

// Example
$result = toObject(
    [
        [ "id" => '1', "name" => 'Alpha', "gender" => 'Male' ],
        [ "id" => '2', "name" => 'Bravo', "gender" => 'Male' ],
        [ "id" => '3', "name" => 'Charlie', "gender" => 'Female' ],
    ],
    'id'
);

/*
[
    1 => ['id' => '0', 'name' => 'Alpha', 'gender' => 'Male',],
    2 => ['id' => '2','name' => 'Bravo','gender' => 'Male',],
    3 => ['id' => '3','name' => 'Charlie','gender' => 'Female',],
]
*/

1.7 Convert an array of strings to numbers

Ici, on peut utiliser la fonction array_map pour appliquer le cast float sur les différentes valeurs du tableau (à noter que la règle n'indique pas si on manipule que des valeurs entières).

function toNumbers($array) 
{
    return array_map(function($value) {
        return (float) $value;
    ], $array);
}

// Example
toNumbers(['2', '3', '4']);     // [2, 3, 4]

1.8 Count by the properties of an array of objects

Enfin une fonction un peu intéressante : compter le nombre d'élements en fonction de leur récurrence dans un tableau.

function countBy($array, $column)
{
    $uniqValues = [];

    foreach ($array as $subArray) {
        if (!isset($uniqValues[$subArray[$column]])) {
            $uniqValues[$subArray[$column]] = 0;
        }
        ++$uniqValues[$subArray[$column]];
    }

    return $uniqValues;
}

// Example
countBy([
    [ 'branch' =>  'audi',  'model' =>  'q8',  'year' =>  '2019' ],
    [ 'branch' =>  'audi',  'model' =>  'rs7',  'year' =>  '2020' ],
    [ 'branch' =>  'ford',  'model' =>  'mustang',  'year' =>  '2019' ],
    [ 'branch' =>  'ford',  'model' =>  'explorer',  'year' =>  '2020' ],
    [ 'branch' =>  'bmw',  'model' =>  'x7',  'year' =>  '2020' ],
], 'branch');

/*
array(3) {
    ["audi"] => int(2)
    ["ford"] => int(2)
    ["bmw"]  => int(1)
}
*/

1.9 Count the occurrences of a value in an array

Voici une première proposition :

function countOccurrences($array, $value)
{
    $occurences = 0;
    foreach ($array as $element) {
        $occurences += $element === $value ? 1 : 0; 
    }

    return $occurences;
}
// Examples
countOccurrences([2, 1, 3, 3, 2, 3], 2);                // 2
countOccurrences(['a', 'b', 'a', 'c', 'a', 'b'], 'a');  // 3

Voici une seconde proposition qui utilise la fonction PHP array_count_values.

function countOccurrences($array, $value)
{
    $arrayCountValues = array_count_values($array);
    $occurences = isset($arrayCountValues[$value]) ? $arrayCountValues[$value] : 0;

    return $occurences;
}
// Examples
countOccurrences([2, 1, 3, 3, 2, 3], 2);                // 2
countOccurrences(['a', 'b', 'a', 'c', 'a', 'b'], 'a');  // 3

1.10 Count the occurrences of array elements

Ici, la fonction array_count_values fait déjà le travail.

function countOccurrences($array) {
    return array_count_values($array);
}
// Examples
countOccurrences([2, 1, 3, 3, 2, 3]);               // [ 1 => 1, 2 =>  2,  3=> 3 ]
countOccurrences(['a', 'b', 'a', 'c', 'a', 'b']);   // [ 'a' => 3, 'b' => 2, 'c' => 1 ]

1.11 Create an array of cumulative sum

Voici une proposition, il existe peut-être une fonction plus courte.

function accumulate($array)
{
    $currentSum = 0;
    $cumulativeArray = [];
    foreach ($array as $element) {
        $currentSum += $element;
        $cumulativeArray[] = $currentSum; 
    }

    return $cumulativeArray;
}

// Example
accumulate([1, 2, 3, 4]);   // [1, 3, 6, 10]

1.12 Create an array of numbers in the given range

La fonction range existe déjà en PHP.

// Example
range(5, 10);   // [5, 6, 7, 8, 9, 10]

1.13 Create cartesian product

Je n'ai pas vraiment compris l'intéret de cette fonction mais voici son équivalence.

function cartesian($arrayA, $arrayB)
{
    $products = [];
    foreach ($arrayA as $elementA) {
        foreach ($arrayB as $elementB) {
            $products[] = [$elementA, $elementB];
        }
    }
    
    return $products;
}

// Example
cartesian([1, 2], [3, 4]);   // [ [1, 3], [1, 4], [2, 3], [2, 4] ]

1.14 Empty an array

Pas besoin de fonction pour ça.

$array = [];

1.15 Find the closest number from an array

Ici, il existe probablement beaucoup de solutions.
Pour cette proposition, on retourne le nombre dont l'écart avec le nombre soumis est le plus faible.
En triant le tableau, cela permet de sortir de la boucle dès lors que l'écart du nombre courant est plus grand que le précédent (on s'écarte de la valeur principale).
Il me semble nécessaire d'initialiser la valeur de l'écart minimal ($minDelta) à null afin que son scope soit clair pour le lecteur (sa première valeur réelle est celle du premier écart et non un entier arbitraire qui serait une source d'erreur).

function closest($array, $value)
{
    sort($array);
    $minDelta = null;
    $previousElement = null;
    foreach ($array as $element) {
        $currentDelta = abs($element - $value);
        if (is_null($minDelta)) {
            $minDelta = $currentDelta;
        } elseif ($currentDelta < $minDelta) {
            $minDelta = $currentDelta;
        } else {
            // The current delta is growing, so the closest number is reached.
            break;
        }
        $previousElement = $element;
    }

    return $previousElement;
}

// Example
closest([29, 87, 8, 78, 97, 20, 75, 33, 24, 17], 50);   // 33

1.16 Find the index of the last matching item of an array

function lastIndex($array, $predicateFunction)
{
    $reversedArray = array_reverse($array);
    foreach ($reversedArray as $index => $element) {
        if ($predicateFunction($element)) {
            return count($array) - $index - 1;
        }
    }

    return null;
}
// Example
lastIndex([1, 3, 5, 7, 9, 2, 4, 6, 8], function($i) {
    return $i % 2 === 1;
}); // 4

lastIndex([1, 3, 5, 7, 9, 8, 6, 4, 2], function($i) {
    return $i > 6;
}); // 5

1.17 Find the index of the maximum item of an array

function indexOfMax($array)
{
    return array_search(max($array), $array);
}
// Examples
indexOfMax([1, 3, 9, 7, 5]);        // 2
indexOfMax([1, 3, 7, 7, 5]);        // 2

1.18 Find the index of the minimum item of an array

function indexOfMin($array)
{
return array_search(min($array), $array);
}
// Examples
indexOfMin([6, 4, 8, 2, 10]);       // 3
indexOfMin([6, 4, 2, 2, 10]);       // 2

1.19 Find the length of the longest string in an array

function findLongest($array)
{
    $longestValue = 0;
    foreach($array as $element) {
        $longestValue = max($longestValue, strlen($element));
    }

    return $longestValue;
}

// Example
findLongest(['always','look','on','the','bright','side','of','life']);  // 6

1.20 Find the maximum item of an array

Le PHP a déjà une fonction max.

1.21 Find the maximum item of an array by given key

function maxBy($array, $column)
{
    $maxValue = null;
    $maxElement = null;
    foreach ($array as $key => $element)
    {
        $elementValue = $element[$column];
        if (is_null($maxValue) || $maxValue < $elementValue) {
            $maxValue = $elementValue;
            $maxElement = $element;
        }
    }
    
    return $maxElement;
}
// Example
$people = [
    [  'name' => 'Bar',  'age' => 24 ],
    [  'name' => 'Baz',  'age' => 32 ],
    [  'name' => 'Foo',  'age' => 42 ],
    [  'name' => 'Fuzz',  'age' => 36 ],
];
maxBy($people, 'age');   // {  'name' => 'Foo',  'age' => 42 }

1.22 Find the minimum item of an array

Le PHP a déjà une fonction min.

1.23 Find the minimum item of an array by given key

function minBy($array, $column)
{
    $minValue = null;
    $minElement = null;
    foreach ($array as $key => $element)
    {
        $elementValue = $element[$column];
        if (is_null($minValue) || $minValue > $elementValue) {
            $minValue = $elementValue;
            $minElement = $element;
        }
    }

    return $minElement;
}
// Example
$people = [
    [  'name' => 'Bar',  'age' => 24 ],
    [  'name' => 'Baz',  'age' => 32 ],
    [  'name' => 'Foo',  'age' => 42 ],
    [  'name' => 'Fuzz',  'age' => 36 ],
];
minBy($people, 'age');   // {  'name' => 'Bar',  'age' => 24 }

1.24 Flatten an array

Un peu de récursif dans cette histoire.

function flat($thing)
{
    $flattenArray = [];
    if (is_array($thing)) {
        foreach ($thing as $element) {
            $flattenArray = array_merge($flattenArray, flat($element));
        }
    } else {
        $flattenArray[] = $thing;
    }
    
    return $flattenArray;
}

// Example
flat(['cat', ['lion', 'tiger']]);   // ['cat', 'lion', 'tiger']

1.25 Get all arrays of consecutive elements

Le PHP a déjà une fonction nommée array_chunk.

1.26 Get all n-th items of an array

function getNthItems($array, $nth)
{
    $items = [];
    foreach ($array as $key => $element) {
        if ((($key+1) % $nth) === 0) {
            $items[] = $element;
        }
    }

    return $items;
}

// Examples
getNthItems([1, 2, 3, 4, 5, 6, 7, 8, 9], 2);    // [2, 4, 6, 8]
getNthItems([1, 2, 3, 4, 5, 6, 7, 8, 9], 3);    // [3, 6, 9]

1.27 Get all subsets of an array

A méditer...

1.28 Get indices of a value in an array

function indices($array, $value)
{
    $indices = [];
    foreach ($array as $key => $element) {
        if ($element === $value) {
            $indices[] = $key;
        }
    }
    
    return $indices;
}

// Examples
indices(['h', 'e', 'l', 'l', 'o'], 'l');    // [2, 3]
indices(['h', 'e', 'l', 'l', 'o'], 'w');    // []

1.29 Get the average of an array

function average($array)
{   
    if (empty($array)) {
        return 0;
    }

    return array_sum($array) / count($array); 
}

// Examples
average([1, 2, 3]); // 2
average([0, 10, 80]); // 30

1.30 Get the rank of an array of numbers

Bon, cette solution n'est surement pas la plus efficace du monde, mais elle fait le job.

function ranking($array)
{
    $ranking = [];
    $rsortArray = $array;
    rsort($rsortArray);
    foreach ($array as $value) {
        foreach ($rsortArray as $rank => $rSortValue) {
            if ($value === $rSortValue) {
                $ranking[] = $rank + 1;
                break;
            }
        }
    }
    
    return $ranking;
}

// Examples
ranking([80, 65, 90, 50]);      // [2, 3, 1, 4]
ranking([80, 80, 70, 50]);      // [1, 1, 3, 4]
ranking([80, 80, 80, 50]);      // [1, 1, 1, 4]

1.31 Get the sum of an array of numbers

Le PHP a déjà une fonction nommée array_sum.

1.32 Get the unique values of an array

Le PHP a déjà une fonction nommée array_unique.

1.33 Get union of arrays

Le PHP a déjà une fonction nommée array_merge.

1.34 Group an array of objects by a key

function groupBy($array, $column)
{
    $groupByArray = [];
    foreach ($array as $element) {
        $groupValue = $element[$column];
        if (!isset($groupByArray[$groupValue])) {
            $groupByArray[$groupValue] = [];
        }
        $groupByArray[$groupValue][] = $element;
    }

    return $groupByArray;
}
// Example
groupBy([
 [ 'branch' =>  'audi',  'model' =>  'q8',  'year' =>  '2019' ],
 [ 'branch' =>  'audi',  'model' =>  'rs7',  'year' =>  '2020' ],
 [ 'branch' =>  'ford',  'model' =>  'mustang',  'year' =>  '2019' ],
 [ 'branch' =>  'ford',  'model' =>  'explorer',  'year' =>  '2020' ],
 [ 'branch' =>  'bmw',  'model' =>  'x7',  'year' =>  '2020' ],
], 'branch');
/*
[
audi: [
        [ 'branch' =>  'audi', 'model' =>  'q8', 'year' =>  '2019' ],
        [ 'branch' =>  'audi', 'model' =>  'rs7', 'year' =>  '2020' ]
    ],
bmw: [
        [ 'branch' =>  'bmw', 'model' =>  'x7', 'year' =>  '2020' ]
    ],
ford: [
        [ 'branch' =>  'ford', 'model' =>  'mustang', 'year' =>  '2019' ],
        [ 'branch' =>  'ford', 'model' =>  'explorer', 'year' =>  '2020' ]
    ],
]
*/

1.35 Merge two arrays

Le PHP a déjà une fonction nommée array_merge.

1.36 Partition an array based on a condition

function partition($array, $partitionFunction)
{
    $partitionnedArray = [[],[]];
    foreach ($array as $element) {
        if ($partitionFunction($element)) {
            $partitionnedArray[1][] = $element;
        } else {
            $partitionnedArray[0][] = $element;
        }
    }

    return $partitionnedArray;
}
// Example
partition([1, 2, 3, 4, 5], function($n) {
    return $n % 2;
});// [[2, 4], [1, 3, 5]]

1.37 Remove duplicate values in an array

Cette fonction supprime les lettres qui sont en doublons (différent donc du array_unique).
function removeDuplicate($array)
{
    return array_keys(array_filter(array_count_values($array), function($value) {
        return $value === 1;
    }));
}

// Example
removeDuplicate(['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']); //  ['h', 'e', 'w', 'r', 'd']

1.38 Remove falsy values from array

Ceci équivaut à filtrer toutes les valeurs considérées commes nulle (0, null, false, '', []).

function removeFalsy($array)
{
    return array_filter($array, function($value) {
        return !empty($value);
    });
}

// Example
removeFalsy([0, 'a string', '', null, true, 5, 'other string', false]); // ['a string', true, 5, 'other string']

1.39 Shuffle an array

Le PHP a déjà une fonction nommée shuffle.

1.40 Sort an array of items by given key

Voici une proposition de solution, on commence par récupérer toutes les valeurs possibles, puis on les trie, et pour chacune des valeurs, on reconstitue un tableau final trié.

function sortBy($array, $column)
{
    $sortedValues = [];
    foreach ($array as $element) {
        $sortedValues[] = $element[$column];
    }
    sort($sortedValues);
    
    $sortByArray = [];
    foreach ($sortedValues as $value) {
        foreach ($array as $element) {
            if($value === $element[$column]) {
                $sortByArray[] = $element;
                break;
            }
        }
    }
    
    return $sortByArray;
}

// Example
$people = [
    [ 'name' =>  'Foo', 'age' =>  42 ],
    [ 'name' =>  'Bar', 'age' =>  24 ],
    [ 'name' =>  'Fuzz', 'age' =>  36 ],
    [ 'name' =>  'Baz', 'age' =>  32 ],
];
sortBy($people, 'age');
/*
[
    [ 'name' =>  'Bar', 'age' =>  24 ],
    [ 'name' =>  'Baz', 'age' =>  32 ],
    [ 'name' =>  'Fuzz', 'age' =>  36 ],
    [ 'name' =>  'Foo', 'age' =>  42 ],
]
*/

1.41 Sort an array of numbers

Le PHP a déjà une fonction nommée sort.

1.42 Split an array into chunks

Le PHP a déjà une fonction nommée array_chunk.

1.43 Swap the rows and columns of a matrix

On suppose ici que la matrice est bien "rectangulaire" (n x m).

function transpose($matrix)
{
    $transposedMatrix = [];
    for ($x = 0; $x < count($matrix) ; $x++) {
        for ($y = 0; $y < count($matrix[0]) ; $y++) {
            if (!isset($transposedMatrix[$x])) {
                $transposedMatrix[$x] = [];
            }
            $transposedMatrix[$x][$y] = $matrix[$y][$x];
        }
    }

    return $transposedMatrix;
}

// Example
transpose([       
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]);
/*
[
    [1, 4, 7],
    [2, 5, 8],
    [3, 6, 9],
]
*/

1.44 Swap two array items

function swapItems($array, $firstItemKey, $secondItemKey)
{
    $savedValue = $array[$firstItemKey];
    $array[$firstItemKey] = $array[$secondItemKey];
    $array[$secondItemKey] = $savedValue;

    return $array;
}

// Example
swapItems([1, 2, 3, 4, 5], 1, 4);   // [1, 5, 3, 4, 2]

1.45 Unzip an array of arrays

function unzip($arrayOfArrays)
{
    $unzippedArray = [];
    foreach ($arrayOfArrays as $subArray) {
        foreach ($subArray as $key => $value) {
            if(!isset($unzippedArray[$key])) {
                $unzippedArray[$key] = [];
            }
            $unzippedArray[$key][] = $value;
        }
    }

    return $unzippedArray;
}

// Example
unzip([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]]);  // [['a', 'b', 'c', 'd', 'e'], [1, 2, 3, 4, 5]]

1.46 Zip multiple arrays

function zip()
{
    $zippedArray = [];
    $arraysToZip = func_get_args();

    for ($i = 0; $i < count($arraysToZip[0]) ; $i++) {
        if (!isset($zippedArray[$i])) {
            $zippedArray[$i] = [];
        }
        foreach ($arraysToZip as $arrayToZip) {
            $zippedArray[$i][] = $arrayToZip[$i];
        }
    }

    return $zippedArray;
}

// Example
zip(['a', 'b', 'c', 'd', 'e'], [1, 2, 3, 4, 5]);   // [['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]]

2. DateTime

2.1 Calculate the number of difference days between two dates

On suppose ici que les deux dates sont des instances de \DateTime.

function diffDays($date, $otherDate)
{
    $dateDiff = $date->diff($otherDate);

    return $dateDiff->days;
}

// Example
diffDays(new \DateTime('2014-12-19'), new \DateTime('2020-01-01')); // 1839

2.2 Calculate the number of months between two dates

On suppose également que les deux dates sont des instances de \DateTime.

function monthDiff($date, $otherDate)
{
    $dateDiff = $date->diff($otherDate);

    return (12 * $dateDiff->y) + $dateDiff->m;
}

// Example
monthDiff(new \DateTime('2014-12-19'), new \DateTime('2020-01-01')); // 153
monthDiff(new \DateTime('2020-01-01'), new \DateTime('2021-01-01')); // 12

2.3 Compare two dates

La fonction retourne true si la première date est supérieure à la seconde, false sinon.
Si on considère que les deux paramètres sont des \DateTime, la simple comparaison suffit.

function compare($a, $b)
{
    return $a > $b;
}

// Example
compare(new \DateTime('2020-03-30'), new \DateTime('2020-01-01'));    // true

2.4 Convert a date to YYYY-MM-DD format

Rien de plus simple avec une instance de DateTime, car format existe déjà.
function formatYmd($date)
{
    return $date->format('Y-m-d');
}

// Example
formatYmd(new \DateTime());      // YYYY-MM-DD

2.5 Convert seconds to hh:mm:ss format

Beaucoup de solutions existent pour ce problème.
La mienne utilise un DateTime. On l'initialise à une date fixe, à laquelle on rajoute un nombre de secondes. Puis on utilise la fonction format.

function formatSeconds($s)
{
    $dateTime = new \DateTime('2020-01-01');
    $dateTime->modify('+'.$s.' SECOND');

    return $dateTime->format('H:i:s');
}

// Examples
formatSeconds(200);     // 00:03:20
formatSeconds(500);     // 00:08:20

2.6 Extract year, month, day, hour, minute, second and millisecond from a date

La solution JS convertie la date en son équivalent string ISO avant d'en extraire les valeurs.
La solution PHP ci-dessous utilise les méthodes de la classe \DateTime pour récupérer les différents données.
NB : la fonction 'extract' existe déjà en PHP.

function extractDateValues(\DateTime $date)
{
    return array(
        $date->format('Y'),
        $date->format('m'),
        $date->format('d'),
        $date->format('H'),
        $date->format('i'),
        $date->format('s'),
        $date->format('u')
    );
}

var_dump(extractDateValues(new \DateTime('2021-05-23 09:45:41')));
/*
array(7) {
    [0]=>
    string(4) "2021"
    [1]=>
    string(2) "05"
    [2]=>
    string(2) "23"
    [3]=>
    string(2) "09"
    [4]=>
    string(2) "45"
    [5]=>
    string(2) "41"
    [6]=>
    string(6) "000000"
}
*/

2.7 Format a date for the given locale

Je n'ai malheureusement pas trouver mieux qu'un switch sur une liste limitée de locales.

function format($date, $locale)
{
    switch($locale) {
        case 'fr_FR':
        case 'pt_BR':
            return $date->format('d/m/Y');
        case 'en_US':
            return $date->format('m/d/Y');
    }
}
// Examples
var_dump(format(new \DateTime('2020-12-11'), 'fr_FR')); // string(10) "11/12/2020"
var_dump(format(new \DateTime('2020-12-11'), 'en_US')); // string(10) "12/11/2020"

2.8 Get the current timestamp in seconds

La fonction PHP time fait cela.

2.9 Get the day of the year from a date

function dayOfYear($date)
{
    return $date->format('z');
}
// Example
var_dump(dayOfYear(new \DateTime('2020-04-16'))); // string(3) "106"

NB : l'exemple JS de 1loc.dev indique aujourd'hui (23/05/2021) 137 comme valeur de retour, ce qui est faux.
Calcul manuel : 31 (janvier) + 28 (février) + 31 (mars) + 16 (avril) = 106

2.10 Get the month name of a date

function getMonthName($date)
{
    return $date->format('F');
}
// Example
var_dump(getMonthName(new \DateTime('2020-04-16'))); // string(3) "April"

2.11 Get the number of days in given month

function daysInMonth($month, $year)
{
    $dateTime = new \DateTime($year.'-'.$month.'-'.'01');

    return $dateTime->format('t');
}
// Examples
var_dump(daysInMonth(2, 2021)); // string(2) "28"
var_dump(daysInMonth(2, 2016)); // string(2) "29"
var_dump(daysInMonth(12, 2016)); // string(2) "31"

2.12 Get the tomorrow date

function tomorrow()
{
    $dateTime = new \DateTime('tomorrow');

    return $dateTime;
}

2.13 Get the weekday of a date

function getWeekday($date)
{
    return $date->format('l');
}
var_dump(getWeekday(new \DateTime('2021-12-11'))); // string(8) "Saturday"

2.14 Get the yesterday date

function yesterday()
{
    $dateTime = new \DateTime('yesterday');

    return $dateTime;
}

2.15 Sort an array of dates

function sortDescending($arr)
{
    rsort($arr); // $arr is passed to the function by reference.
    
    return $arr;
}
// Example
sortDescending(array(new \DateTime('2019-01-12'), new \DateTime('2011-04-23'), new \DateTime('2017-05-01')));

function sortAscending($arr)
{
    sort($arr); // $arr is passed to the function by reference.

    return $arr;
}
// Example
sortAscending(array(new \DateTime('2019-01-12'), new \DateTime('2011-04-23'), new \DateTime('2017-05-01')));

2.16 Add AM PM suffix to an hour

function suffixAmPm($hour)
{
    $dateTime = new \DateTime();
    $dateTime->setTime($hour, 0);
    
    return $dateTime->format('ga');
}
// Examples
var_dump(suffixAmPm(0));  // string(4) "12am"
var_dump(suffixAmPm(5));  // string(3) "5am"
var_dump(suffixAmPm(12)); // string(4) "12pm"
var_dump(suffixAmPm(15)); // string(3) "3pm"
var_dump(suffixAmPm(23)); // string(4) "11pm"

2.17 Get the first date in the month of a date

function getFirstDate($d)
{
    $firstDateTime = new \DateTime($d->format('Y').'-'.$d->format('m').'-01');

    return $firstDateTime;
}

// Example
var_dump(getFirstDate(new \DateTime('2020-12-11'))); //[...]"2020-12-01 00:00:00.000000"[/...]

2.18 Get the last date in the month of a date

function getLastDate($d)
{
    $lastDateTime = new \DateTime($d->format('Y').'-'.$d->format('m').'-'.$d->format('t'));

    return $lastDateTime;
}

// Example
var_dump(getLastDate(new \DateTime('2020-12-11'))); //[...]"2020-12-31 00:00:00.000000"[/...]

2.19 Get the timezone string

function getTimezone()
{
    $dateTime = new \DateTime();
    $dateTimeZone = $dateTime->getTimezone();

    return $dateTimeZone->getName();
}

// Example
var_dump(getTimezone()); // string(13) "Europe/Berlin"

2.20 Get the current quarter of a date

Le numéro du trimestre :
* De janvier à mars : 1er trimestre
* D'avril à juin : 2ieme trimestre
* De juillet à septembre : 3ieme trimestre
* D'octobre à décembre : 4ieme trimestre

function getQuarter($d)
{
    return intval(ceil($d->format('m')/3));
}

// Example
var_dump(getQuarter(new \DateTime('2021-12-04'))); // int(4)
var_dump(getQuarter(new \DateTime('2021-02-04'))); // int(1)

NB : contrairement à la fonction JS, il n'y a pas besoin d'incrémenter le numéro du mois de 1.

2.21 Get the total number of days in a year

function numberOfDays($year)
{
    $lastDay = new \DateTime($year.'-12-31');

    return $lastDay->format('z');
}

//Examples
var_dump(numberOfDays(2021)); // string(3) "364"
var_dump(numberOfDays(2016)); // string(3) "365"

2.22 Initialize the current date but set time to midnight

function midnightOfToday()
{
    $clonedDate = new \DateTime();
    $clonedDate->setTime(0, 0);

    return $clonedDate;
}

// Example
var_dump(midnightOfToday()); // object(DateTime)#1 (3) {[...] string(26) "2021-05-23 00:00:00.000000"[/...]}